Aggregated cheatsheets of all tutorials

This aggregated cheatsheet of our tutorial package Introduction to programming with R summarizes the individual notes from the provided tutorials and additional information from recommended sources.

R, RStudio, coding, packages

• == operator tests for equality of things; != for inequality
• = is used for assignment of values to arguments (don’t use for object assignment!)
• Boolean statements work on and result in TRUE/FALSE values
  • can be combined using logical operators like & (AND), | (OR), and ! (NOT)
• functions, aka commands, are the workhorses in R and always come with a () after their name
• c() combines/concatenates multiple values into one vector object
• install.packages() installs a new package via its name from the console (also possible via ‘Packages’ menu in RStudio)
• a package is a collection of additional functions and data objects, examples are
  • ggplot2 for visualization
  • dplyr for data transformation
  • important packages for data processing covered in this course are loaded via the meta-package tidyverse
• library() loads a package via its name
  • this command is typically missing if your R doesn’t know/find the function you want to use!

Cheatsheet “first-steps”

• in tidy tabular data
  • a row represents one observation, i.e. a single thing you want to talk about
  • a column is a variable, i.e. a feature that might be vary between observations

Cheatsheet “ggplot-basics”

• help() provides details information on functions, data sets, packages
  • ? short version
• head() first elements of object
• glimpse() (from dplyr package) compact variable view of tabular data
  • one line per variable column
  • Summary page
• R combines multiple lines into one call if at the end of a line
  • there is an operator like +, <-, =, …
  • it misses still a closing bracket or brace, i.e. ), ], }, or closing quote, i.e. ", '
• ggplot2 is the visualization package
  • ggplot() defines what data to plot (and general/shared aesthetics)
    • data = first argument = what tidy data table to visualize
  • geom_...() defines how to plot the data, i.e. the plot geometry, e.g.
    • geom_point() (Summary page)
    • geom_line() (Summary page)
    • geom_smooth() (Summary page)
  • + combines different geometries, labels, etc. into one plot
    • e.g. ggplot(mtcars, mapping=aes(x=wt, y=mpg)) + geom_point() + xlab("weight")
  • mapping argument takes aes() aesthetics, which defines what data variables from the input table are used where in the plot, i.e. their mapping (Summary page)
    • when defined in ggplot(): applied to all subsequent geom_*() functions
      • e.g. ggplot(mtcars, mapping=aes(x=wt, y=mpg)) + geom_point()
    • when defined e.g. in geom_point(): only used when doing this point drawing
      • e.g. ggplot(mtcars) + geom_point(mapping=aes(x=wt, y=mpg))

Workflow basics

• variable names
  • can contain numbers, letters, . and _
  • have to start with a letter
  • should be self-explanatory
  • capitalization matters, i.e. myname is not myName
• use <- for object assignment (RStudio hot key = ‘ALT’ + ‘-’)
• seq() generates a vector of subsequent numbers, e.g. seq(2,5) is equal to c(2,3,4,5)
• text/string/character values have to be quoted, i.e. surrounded by ticks
  • use either '' or "", both works
  • ensure closing tick for any opening
• writing a variable name in the console prints it, i.e. x is equal to print(x)
  • surrounding a term in round brackets () triggers printing implicitly
• RStudio: hot key ‘ALT’+‘SHIFT’+‘K’ shows all hot key combinations

Cheatsheet “Tibbles”

• tibble = data structure to store tabular data (tidyverse extension of data.frame structure)
  • (Summary page)
• can be manually created via
  • vectorized (column-wise) input, i.e. p2 <- tibble( x = 0:3, y = c(1,2,4,8)) (as done for data.frame or list)
    • when defining columns you can already used previously defined columns, e.g. p2 <- tibble( x=0:3, y=2^x)
  • row-wise transposed tibble, i.e. p2 <- tribble( ~x, ~y, 0, 1, 1, 2, 2, 4, 3, 8) (put line breaks where appropriate)
• column/variable access (vector data structure) via
  • $colName = dollar + name-based (most recommended), e.g. p2$y
  • [["colName"]] = double-squared + quoted name as done for lists, e.g. p2[["y"]]
  • [[2]] = double-squared + index-based (try to avoid), e.g. p2[[2]]
    • Beware: you get a tibble (i.e. table data structure) when using [] = single-squared + index, not a column vector!
• quote column/variable names not meeting standard syntax requirements (e.g. with spaces etc.)
  • table[["strange name"]] - quotes in double-bracket usage
  • table$`strange name` - back-ticks in direct name-based access
• glimpse(p2) to check column names and resp. data types
• as_tibble() converts an object into a tibble (if possible)
• is_tibble() checks whether it is a tibble
• str()provides the data structure of an R object, i.e. how it is organized and what’s inside

Cheatsheet “dplyr-filter”

• vector creation via c() (concatenate)
• conditional statements/functions result in logical values (TRUE or FALSE)
  • ==, !=, >, <, <=, >=
  • &, |, xor()
  • !
  • %in% vector
  • between() (dplyr)
  • near() better for floating point number comparison than ==
• filter() prunes table to rows of interest (Summary page)
  • all rows for which the conditional statement is TRUE pass the filter and are kept; all others are removed
  • multiple sequential filter steps separated by comma or &
  • direct use of variable (column) names in filter criteria
  • brackets in conditional statements are often important!
• %>% piping for connection of data transformation steps
  • (first) input argument of subsequent function automatically set (with result of last)
• summary() statistical overview of values in data structure; e.g. for each variable of a data frame

Cheatsheet “dplyr-arrange-select”

• arrange() changes the order of rows (Summary page)
  • multiple (comma-separated) variable names define a sorting hierarchy (left-to-right) that is used for tie breaking
  • default = ascending order
  • desc() around a variable triggers descending sorting w.r.t. the variable’s values
  • NA is always last
• select() reduces the columns to variables of interest (Summary page)
  • comma-separated variable list or vector notation (using c())
    • : generates a vector of ascendingly increasing elements (from:to) including the boundaries
    • specified order = new order of columns (can be used for reordering)
      • everything() : all variables not named so far (useful for reordering of columns)
      • duplicated names are ignored
  • ! or - negation removes the specified variables (also works for vectors via c() or :)
  • selection can be specified via names (quoted and unquoted) as well as numbers
  • starts_with(), ends_with(), contains() : parts of variable names
  • matches() : regular expression on names (discussed later)
  • num_range() : combines strings and number vectors to full names like x1, x2, …
  • any_of() : listed variable names not necessarily present in data table (useful for negative selection without errors/warnings)

Cheatsheet “dplyr-mutate”

• mutate() creates new variables (columns) (Summary page)
  • format is NAME = EXPRESSION
  • multiple variables can be created (subsequently) in one mutate() calls
    • you can directly use previously created variables
• transmute() creates a new table with new variables (dropping the input table)
  • produces one row for each row of the input table
• creation functions
  • are done row-wise on the whole column at once
    • i.e. when computing A-B, respective A and B values from each row from both columns are subtracted (creating a new vector with the same length as both columns; one result for each row in the same row-order)
  • if a function works that way it is called a vectorized functions
  • common operations:
    • arithmetic operations (for numbers only): +, -, *, /, ^ (power), log..()
    • modular operations (for integers only): %/% and %%
    • logical comparison: <, ==, !=, >=, …
    • logical operations (working on TRUE/FALSE): &, |, !
    • cum...() = rolling …, e.g. 
      • cumsum()/cumprod = rolling sum/product of consecutive values (= vector of values)
      • cummin()/cummax = min/max of all rows up to here
      • cummean()
    • rank of each value (within sorted order of values within variable), e.g.
      • min_rank() or dense_rank() (typically one of both is what you are looking for)
      • or percent_rank(), row_number(), …
    • offset, i.e. column is shifted up or down by n rows
      • lag() = previous values, i.e. shifting the column down (adding NAs at the beginning)
      • lead() = following values, i.e. shifting the column up (adding NAs at the end)
    • aggregative functions like
      • sum() = sum of all values in the variable column (= single value)
      • mean()
• recycling rule = if one operator element is too small, it is repeated to the needed length!
  • longer length needs to be multiple of shorter length!
  • e.g. both c(1,2,3,4)+1 and c(1,2,3,4)+c(1,2) are working while c(1,2,3)+c(1,2) is not
  • best use with single values only!

Cheatsheet “dplyr-groupby-summarize”

• summarize() produces only a single output row (per group) (Summary page)
  • computes statistical properties of variables (or combinations)
  • when statistics on groups: good idea to report/check group size via n()
  • ‘consumes’ a previous grouping via ‘group_by()’, i.e. merges the rows per group into one table
• group_by() decomposes the observations (Summary page)
  • i.e. decomposing the table into subtables that show the same value w.r.t. the grouping variable
  • multiple grouping variables can be given (comma-separated) to specific a grouping hierarchy
  • subsequent group_by() calls overwrite the grouping of the previous!
  • all subsequent operations are done independently per group
• ungroup() explicitly undoes the previous group_by() and merges the subtables back into one
• aggregation functions
  • mean(), median(), quantile(), sd()
  • min(), max(), first(), last(), nth()
  • n(), n_distinct()
  • sum()
    • sum() of logical values == number of TRUEs (since scored 1, where FALSE is scored 0)
  • can be used anywhere, also in mutate(), filter(), …
  • NA handling important (set na.rm=TRUE argument if wanted)
• count() is a summary based on counting or summation only

Cheatsheet “dplyr-sundries”

• rename() allows to alter variable names (Summary page)
  • format: <NEWNAME> = <OLDVAR> where OLDVAR can be
    • an index number or
    • the old name of the column to rename
• colnames() give you the vector of a table’s column names (base R)
• slice functions extract specific rows (Summary page)
  • slice() - columns specified by indices
  • slice_min(), slice_max() - best/worst rows w.r.t. values in a given variable
    • be aware of ranking ties during min/max slicing
    • use with_tie=F to get only first min/max row
  • slice_head(), slice_tail() - top/tail rows w.r.t. current row order
  • slice_sample() - pick at random
  • set n=.. argument for number of rows
  • set prop=.. argument to specify a fraction of rows to keep
• distinct() reduces the table to unique observations (Summary page)
  • if a (set of) variable name(s) is given, only first rows with a unique value combination w.r.t. the named variables are kept
  • .keep_all=TRUE no columns are removed from the output
• join functions allow to fuse information from multiple tables into one
  • this is called a mutating join (Summary page)
  • increases data redundancy but allows for subsequent “tidy” data analyses and ggplot visualizations
  • joining is done based on equal values in respective key columns
    • by = X - same column name X in both tables
    • by = c(X = Y) - merge based on X column in first table and Y variable from second table
  • missing values produce NA entries
  • left_join() keeps all rows from first table
  • inner_join() - only observations with values in both tables
  • full_join() - all vs. all combinations
• dplyr package covers even more verbs, see
  • dplyr reference page
  • Cheatsheet

Cheatsheet “Data import/export”

• initial data collection in spreadsheets should follow
  • principles of data organisation
• readr package (Summary page)
  • read_delim() - columns are separated by a single letter given to delim argument
    • read_csv() - using , as column delimiter
    • read_csv2() - columns delimited by ; and German ,-based decimal number notation
    • read_tsv() - tabular as column delimiter
  • read_fwf() - fixed width column specification (fixed number of letters per column)
  • locale argument defines language specifications like decimal separator, names of days/months, date/time encoding, letter encodings, …
    • e.g. locale=locale(decimal_mark=",", grouping_mark=".") = German number notation
    • e.g. locale=locale(encoding="latin1") = using the Latin-1 letter encoding typically used on Microsoft Windows systems to enable a correct rendering of umlauts etc.
  • quote='"' to specify quotation letter
  • col_types=list(colName="c") allows to specify the data type of (individual) columns
  • na='--' takes a vector of (string) values to be treated as not available (NA)
• data can be typically read from
  • file (on you computer) with or without path information (check working directory)
  • url (internet address)
  • text (variable)
  • works also for compressed files (ending with .gz, .bz2, .xz)
• the “working directory” of the R session defines from/to where to read/write files (enables relative path specification!)
  • getwd() and setwd()
  • can be changed via menu “Session >> Set Working Directory” in RStudio
  • also possible via “File” tab in RStudio
  • common issue for problems with data import!
• corresponding write functions
  • e.g. write_csv(DATATABLE, FILENAME)
  • use write_csv2() if you need a , decimal separator (no manual locale specification possible!)
• additional packages
  • readxl for MS Excel import (Summary page)
  • writexl for (simple) MS Excel export (Summary page)
  • googlesheets4 for import/export of online Google Sheets (Summary page)

Cheatsheet “Making data tidy”

• tidy data implements the following

• tidyr package (Summary page)
  • pivoting = conversion of table format from/to wide/long
    • pivot_longer() = column names go to “names” column (and values to one column)
    • pivot_wider() = values from one column are distributed over multiple columns
  • NA handling
    • fill() replaces NA with previous/subsequent non-NA value in column
    • complete() adds implicitly missing value combinations
    • drop_na() removes rows with NA
    • replace_na() new value for NA entries
  • (de)composition of text/character values
    • separate() decomposes a variable’s text values into multiple columns
    • unite() joins multiple variables into one text column

Cheatsheet “stringr::basics+regex”

Strings

• strings need to be quoted (single ' or double " quotes)
• escaping via \ of special characters like line-break \n, tabulator \t, …
• non-keyboard symbols/characters via UTF encoding (\uXXXX for UTF-16 and \U.. for UTF-32 encodings), e.g. "greek alpha = \u03B1"
• writeLines() : final text output in the console (e.g. for testing/checking)
• str_length() : number of characters/letters
• str_c() or paste(): concatenation of strings
  • element wise processing with separator sep string
  • collapse/aggregation to one string via collapse string
  • empty strings (length == 0) are ignored
• str_sub(): extracting a substring, i.e. part, of a string
  • start and end indices are inclusive
• str_to_lower(), str_to_upper(), str_to_title() : capitalization conversion
  • use locale for language specifics _ str_sort() : lexicographic sorting
  • again locale specific
• str_trim()/str_pad() : remove/add whitespaces at strings’ ends

Regular expressions

• regular expressions (regex) are powerful tools to process text
  • “placeholders” to encode character classes
    • . : any letter (but no newline per default)
    • Note: class symbols need double-escaping in string encodings!!!
    • \\d (\\D) : (not a) digit
    • \\s (\\S) : (not a) whitespace, i.e. space, tabulator, ..
    • \\w : (english) word letter or digit
    • [] : explicit letter list (use [^] for negation of list)
  • anchors define where the pattern match should start/end
    • ^ : beginning of the text
    • $ : end of the text
    • \\b : end of a word (left or right)
  • | alternative separator, e.g. a|b matches a or b
  • () to group or capture blocks of a pattern, e.g. to
    • specify alternatives go (left|right)
    • backreference to the submatch within the capture group
      • e.g. (['"])[^'"]\1 to match a text that is quoted by single OR double ticks but using the same tick at the beginning and end
  • repetition rules allow for compact the encoding of substrings
    • ? : 0 or 1 times
    • * : 0 or multiple times
    • + : 1 or multiple times
    • {} : explicit counts {3}, ranges {2,4} or “at least/most” {2,},{,3}
    • regex matching is greedy, i.e. the longest possible match is searched
      • e.g. str_view("aaaa","a+") reports the whole string as match and not only one letter!
    • repetition rules also apply to groups, i.e. (ab)+ matches "ababab"
• str_view() shows pattern matches within the input strings (e.g. for regex testing)
  • match=T : show hits only (also useful to list not-matched strings)
• str_subset() provides the subset of input elements (a vector of strings) that match the given regex, e.g. str_subset(c("a","b","c"), "a|b")

Cheatsheet “stringr::processing”

• str_detect() : logical T|F if a string contains a pattern
• str_subset() : all elements that contain a pattern
• str_count() : number of pattern occurrences per string
• str_extract() : only overall match of the search pattern
• str_match() : overall match + each group match of the search pattern
• str_replace() : replacement of matches
  • use back referencing to use groups of the match within the replacement
  • e.g. str_replace("A B", ".*(\\S+)$", "last word was '\\1'")
• str_split() : decompose into multiple strings
  • simplify=TRUE returns a matrix rather than a list
  • n=.. number of final pieces, i.e. matches(+1) used for decomposition
  • boundary() : general regex for matching of boundaries of words, sentences, …
• str_locate(): position of the match (start+end)
• .._all() variants : returns all matches not only the first

All regular expression strings are processed by

• regex(), which can be further constraint if needed, e.g. using
  • ignore_case : case insensitive matching
  • multiline : treats \n like string ends (for ^ and $ matching)
  • dotall : will make . also match linebreaks \n and other stuff

Also important:

• intersect() provides the elements shared among two vectors
• unlist() merges all elements of a list into a single vector
• unique() provides the unique elements of a list or vector
• matrix is like a table-version of a vector (all elements same data type)

Cheatsheet “coding-basics”

• important data structures
  • vector = all elements are same data type
  • list = most general, can contain anything, any size, …
  • data.frame/tibble = list of vectors (of same lengths)
    • ==> if tidy, resp. column values (in one row) are associated with one observation
• subsetting can be done using
  • [] = reduces the current object to the selected part(s) (same data container)
  • [[]] = provides a single element (element-specific data container)
  • $ = shortcut for [[]] with name
• programming of workflows often requires
  • iteration of code blocks (for or while loops)
    • for( VARIABLE in DATA ) {...}
    • each element of DATA is one by one stored in VARIABLE before running {...}
    • e.g. for( d in list( x="haha", y=1:3)) { print(length(d)) }
  • conditional code execution (if/else statements)
    • if ( CONDITION ) {..T..} else {..F..}
    • else {..B..} is optional
    • CONDITION must evaluate to a single TRUE|FALSE: triggers execution of respective {..T|F..} block
      • e.g. if ( 1:4 == 2 ) {} not working since check returns four logic values!
    • e.g. if ( version$os == "mingw32" ) { print("MS Windows user?") }
  • generalization of code blocks (function definition and usage)
    • myFunction <- function (ARGUMENTS) {...}
    • ARGUMENTS are optional (first should be the data to work on)
    • run via myFunction( .. ) using appropriate values for ARGUMENTS
    • return via return() in {...} (default: last “printed” value is returned)
    • to return multiple values, aggregate them in list() or vector c()
• redundant code w.r.t. values of a variable ==> for loop generalization
• redundant code w.r.t. variables or function calls ==> function generalization
• iteration tricks
  • best iterate directly on the elements, if you don’t need the element names or index!
  • use seq_along() to generate the list of valid indices of a vector or list
  • use names() to access the vector of element names of an object
• when a function calls itself it is called a recursive call or recursion
• function names (without brackets) can be stored in and used from variables/arguments to call the functions

---

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.

Feel free to contribute at https://github.com/Dr-Eberle-Zentrum/Introduction-to-programming-with-R.